{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Working with jobs\n", "\n", "The job class obtained after running a QuantumCircuit has interesting properties that can be used." ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
┌───┐ \n", "q_0: ┤ H ├──■──\n", " └───┘┌─┴─┐\n", "q_1: ─────┤ X ├\n", " └───┘" ], "text/plain": [ " ┌───┐ \n", "q_0: ┤ H ├──■──\n", " └───┘┌─┴─┐\n", "q_1: ─────┤ X ├\n", " └───┘" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import os\n", "from c12_callisto_clients.user_configs import UserConfigs\n", "from c12_callisto_clients.qiskit_back.c12sim_provider import C12SimProvider\n", "from qiskit import QuantumCircuit\n", "TOKEN = os.getenv(\"C12_TOKEN\")\n", "configs = UserConfigs.parse_obj({\"token\" : TOKEN})\n", "\n", "c12_simulator_provider = C12SimProvider(configs)\n", "c12_simulator_backend = c12_simulator_provider.get_backend('c12sim-iswap')\n", "\n", "\n", "circuit = QuantumCircuit(2)\n", "circuit.h(0)\n", "circuit.cx(0, 1)\n", "\n", "circuit.draw()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Two main methods available for each Job instance are job_id() and status().\n", "\n", "1. `job_id()` method returns the unique identifier of a job as a UUID4 string (a universally unique identifier (UUID), version 4, is a 36-character alphanumeric random generated string). This id can be used for later assessment of the job properties.\n", "\n", "2. `status()` method is used to get the status of a job execution as an instance of JobStatus class. Available statuses are:\n", " - `QUEUED` = Job is queued. It waits for execution\n", " - `RUNNING` = Job is currently running.\n", " - `CANCELLED` = Job has been canceled.\n", " - `DONE` = Job has been successfully done.\n", " - `ERROR` = There has been an error during the execution of a job.\n", "\n", "The status of a running job can be changed depending on the current state of job execution.\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Job id: 023e408a-bb92-4f48-a5c5-2336bcc8b21e\n", "Status: JobStatus.RUNNING\n" ] } ], "source": [ "c12_job = c12_simulator_backend.run(circuit)\n", "print(f\"Job id: {c12_job.job_id()}\") # Get a job UUID\n", "print(f\"Status: {c12_job.status()}\") # Get a current job status" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The result of a job execution can be obtained with the `result()` method. This method can have one optional argument (timeout). The `timeout` argument specifies how long the method will wait for the execution of the task. If the time limit is exceeded, the `C12SimJobError` exception is raised. If we do not specify this argument, its default value is None, meaning the method will block until the simulation is finished.\n", "\n", "Another way to get the results is to check the job status periodically until it is `DONE` and then call the `result()` function." ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "023e408a-bb92-4f48-a5c5-2336bcc8b21e: JobStatus.RUNNING\n", "023e408a-bb92-4f48-a5c5-2336bcc8b21e: JobStatus.DONE\n", "{'00': 487, '01': 1, '10': 2, '11': 534}\n" ] } ], "source": [ "from qiskit.providers import JobStatus\n", "import time\n", "job_final_states = [JobStatus.DONE, JobStatus.ERROR, JobStatus.CANCELLED]\n", "c12_job_id = c12_job.job_id()\n", "while True:\n", " job_status = c12_job.status()\n", " print(f'{c12_job_id}: {job_status}')\n", " if job_status in job_final_states:\n", " break\n", " time.sleep(5) # Wait 5 s\n", "\n", "if c12_job.status() == JobStatus.DONE:\n", " c12_result = c12_job.result()\n", " print(c12_result.get_counts())" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'00': 517, '01': 2, '10': 1, '11': 504}\n" ] } ], "source": [ "# Running a job that will block until finished\n", "c12_job = c12_simulator_backend.run(circuit)\n", "c12_result = c12_job.result()\n", "if c12_job.status() == JobStatus.DONE:\n", " print(c12_result.get_counts())" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false }, "outputs": [], "source": [ "# Getting a job result with a timeout argument specified\n", "from c12simulator_clients.qiskit_back.exceptions import C12SimJobError\n", "c12_job = c12_simulator_backend.run(circuit)\n", "\n", "try:\n", " c12_result = c12_job.result(timeout=15) # it will raise a C12SimJobError as it won't be finished in 15s\n", "except C12SimJobError:\n", " print(\"Timeout!\")\n", " print(f\" Last status: {c12_job.status()}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Getting previous jobs\n", "\n", "Next, an extremely useful functionality is the possibility to obtain all jobs run on the system by a specific user. Using this functionality, the user can get the results of old jobs.\n", "\n", "This can be achieved by calling the `jobs()` function on the backend instance. This function accepts two arguments: `limit` and `offset`. We can specify how many jobs we want to get with a `limit` argument. Likewise, we can set the `offset` from the first job with an offset argument. With these arguments, pagination is easily achieved." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1: a7fadc44-22f7-42a1-9056-cd05f510a279 Status: JobStatus.DONE\n", "2: 7b646f18-198d-40d7-a3f1-cb87cb6cc7a7 Status: JobStatus.DONE\n", "3: c62fe639-e53a-49ec-bc15-c0d7284d723a Status: JobStatus.DONE\n", "4: 56497e19-2105-484f-a6e6-23f29445030e Status: JobStatus.DONE\n", "5: d369dceb-2bf0-42ae-9fc0-eba869e388a2 Status: JobStatus.DONE\n", "6: 72fc139b-7d58-429a-806d-9030b90fd155 Status: JobStatus.DONE\n", "7: 0281d8f6-7ba7-49e8-97d7-8e0ee2b6da32 Status: JobStatus.DONE\n", "8: 259c317d-8a14-433e-a6d0-4595da57bbc8 Status: JobStatus.DONE\n", "9: 901a0c54-47bd-4caf-9130-dadb11ffc020 Status: JobStatus.DONE\n", "10: 41d70035-4510-42a1-b8a9-20128bae359f Status: JobStatus.DONE\n" ] } ], "source": [ "number_of_records = 10\n", "offset = 0\n", "counter = 1\n", "\n", "jobs = c12_simulator_backend.jobs(number_of_records, offset)\n", "\n", "for job in jobs:\n", " print(f\"{counter}: {job.job_id()} Status: {job.status()}\")\n", " counter += 1\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For each job, it is possible to get the circuit sent to the simulator for execution. But, it is even possible to get the transpiled version of this circuit to see what the circuit has been run after the transpilation process." ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "